Deployment of database objects

ABSTRACT

A system, a method, and a computer program product for deploying of objects are disclosed. At least one file containing a plurality of artifacts for deploying during runtime of an application is defined. Each artifact in the plurality of artifacts includes at least one object in the plurality of objects required to be deployed during runtime of the application. At least one dependency for at least one artifact in the plurality of artifacts is determined. An execution order for deployment of the plurality of artifacts is generated. The plurality of artifacts is deployed in accordance with the generated execution order.

TECHNICAL FIELD

This disclosure relates generally to data processing and, in particular, to deployment of database objects.

BACKGROUND

Businesses use a plurality of business process applications and/or services in their business operations. Applications and/or services can be programs that an end-user runs to accomplish certain tasks and can work in conjunction with one or more back-end systems, which can store the data to be worked on, such as, for example, business objects and other business data, as well as logic for manipulating the data, such as for example transactions or other business logic. Examples of back-end systems may include database systems, enterprise resource planning (“ERP”) systems, and customer relationship management (“CRM”) systems. A user interface (“UI”) can be designed to work in concert with application programs, and facilitates interaction between humans and computers by inviting and responding to user input. In order to accomplish various tasks, a user can initiate various applications, tasks, agents, etc. that may manipulate data in different ways to achieve results desired by the user.

Users can design and/or create various business process objects, such as sales orders, invoices, etc. A business object can be created using any known computing systems and languages (e.g., one such exemplary language includes advanced business application programming (“ABAP”) high level programming language, which is available from SAP SE, Walldorf, Germany). Such created objects can be stored in memory, such as in a database. An example of such database includes a High-Performance Analytic Appliance (“HANA”), which is a column-oriented, in-memory database appliance available from SAP SE, Walldorf, Germany. Objects can be created at design-time for execution at runtime of an application. To accommodate design-time creation and runtime execution, objects need to be deployed at the database. Deployment of objects can be a complicated process and conventionally, can involve a multitude of aspects, such as version control, lifecycle management, special programs, application layer artifacts, and others. This can significantly hinder efficient implementation of database systems, dependency management among objects, etc. Thus, there is a need for a transactional all-or-nothing deployment model that can simplify deployment of database systems.

SUMMARY

In some implementations, the current subject matter relates to a method for deploying of objects. The method can include defining at least one file containing a plurality of artifacts for deploying during runtime of an application. Each artifact in the plurality of artifacts can include at least one object in the plurality of objects required to be deployed during runtime of the application. The method can also include determining, based on the defining, at least one dependency for at least one artifact in the plurality of artifacts, generating, based on the determining, an execution order for deployment of the plurality of artifacts, and deploying the plurality of artifacts in accordance with the generated execution order. At least one of the defining, the determining, the generating, and the deploying can be performed by at least one processor of at least one computing system.

In some implementations, the current subject matter can include one or more of the following optional features. In some implementations, the deployment can include at least one of the following: undeploying the artifact, deploying a modified version of the artifact, and re-deploying the artifact.

In some implementations, the method can also include determining whether the artifact is cyclically dependent on another artifact in the plurality of artifacts, prohibiting deployment of the artifact and another artifact based on a determination that the artifact and another artifact do not belong to the same build plugin (where the plugin is used to deploy the artifact at runtime of the application), and permitting deployment of the artifact and another artifact based on a determination that the artifact and another artifact belong to the same plugin.

In some implementations, the method can include generating a dependency graph for the plurality of the artifacts based on the plurality of required objects, where the execution order is generated based on the generated dependency graph.

In some implementations, the deployment can include initially deploying, based on the generated execution order, the plurality of artifacts, modifying an artifact in the plurality of artifacts, generating a modified execution order, where the modified execution order specifies deployment of the modified artifact, and deploying the plurality of artifacts including the modified artifact based on the modified execution order. The method can also include determining another artifact in the plurality of artifacts being dependent on the artifact, and redeploying another artifact as a result of the modification of the artifact. The method can further include determining another artifact in the plurality of artifacts being dependent on the artifact, and undeploying another artifact prior to deploying the modified artifact, deploying the modified artifact, and redeploying another artifact after deploying the modified artifact.

In some implementations, the dependency can include at least one of the following: the artifact being dependent on at least another artifact in the plurality of artifacts and the artifact being independent of any artifact in the plurality of artifacts.

Non-transitory computer program products (i.e., physically embodied computer program products) are also described that store instructions, which when executed by one or more data processors of one or more computing systems, causes at least one data processor to perform operations herein. Similarly, computer systems are also described that may include one or more data processors and memory coupled to the one or more data processors. The memory may temporarily or permanently store instructions that cause at least one processor to perform one or more of the operations described herein. In addition, methods can be implemented by one or more data processors either within a single computing system or distributed among two or more computing systems. Such computing systems can be connected and can exchange data and/or commands or other instructions or the like via one or more connections, including but not limited to a connection over a network (e.g., the Internet, a wireless wide area network, a local area network, a wide area network, a wired network, or the like), via a direct connection between one or more of the multiple computing systems, etc.

The details of one or more variations of the subject matter described herein are set forth in the accompanying drawings and the description below. Other features and advantages of the subject matter described herein will be apparent from the description and drawings, and from the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are incorporated in and constitute a part of this specification, show certain aspects of the subject matter disclosed herein and, together with the description, help explain some of the principles associated with the disclosed implementations. In the drawings,

FIG. 1 illustrates an exemplary system implementing a deployment infrastructure, according to some implementations of the current subject matter;

FIG. 2 illustrates an exemplary container in a database schema, according to some implementations of the current subject matter;

FIG. 3 illustrates exemplary multiple container system in a database schema, according to some implementations of the current subject matter;

FIG. 4 illustrates an exemplary deployment API system, according to some implementations of the current subject matter;

FIG. 5 illustrates an exemplary system for performing deployment infrastructure administration and container management, according to some implementations of the current subject matter;

FIG. 6 illustrates an exemplary system having container-level deployment application program interfaces, according to some implementations of the current subject matter;

FIG. 7 illustrates an exemplary system that can use different technical users during deployment (such as during a single transaction), according to some implementations of the current subject matter;

FIG. 8 illustrates exemplary artifacts and provided/required objects, according to some implementations of the current subject matter;

FIG. 9 illustrates exemplary dependencies between objects, according to some implementations of the current subject matter;

FIG. 10 illustrates an exemplary execution graph for deployment of dependent objects, according to some implementations of the current subject matter;

FIGS. 11a-d illustrate exemplary deployment strategies, according to some implementations of the current subject matter;

FIGS. 12a-c illustrate exemplary cyclic dependencies of objects, according to some implementations of the current subject matter;

FIG. 13 is a diagram illustrating an exemplary system including a data storage application, according to some implementations of the current subject matter;

FIG. 14 is a diagram illustrating details of the system of FIG. 13;

FIG. 15 illustrates an exemplary system, according to some implementations of the current subject matter; and

FIG. 16 illustrates an exemplary method, according to some implementations of the current subject matter.

DETAILED DESCRIPTION

In some implementations, the current subject matter relates to a deployment infrastructure for a High Performance Analytic Appliance (“HANA”, as developed by SAP SE, Walldorf, Germany). The deployment infrastructure can be a service layer of the HANA database that can simplify deployment of HANA database artifacts, i.e., design-time objects (e.g., tables, views, etc.). This can be accomplished by providing declarations that define database objects and by ensuring consistent deployment into the database. In some implementations, the deployment can be based on a transactional all-or-nothing deployment model as well as an implicit dependency management. The deployment infrastructure can implement use of containers that can allow multiple deployments and sandboxing. The deployment infrastructure can be used to deploy design-time objects of applications, databases, etc.

In some implementations, the deployment infrastructure can focus on deployment aspects and address development and/or modeling scenarios as part of the HANA database and/or extended application services (“XS”, as developed by SAP SE, Walldorf, Germany). Further, the deployment infrastructure can provide artifacts for HANA database objects, e.g., tables, views, calculation views, procedures, core data services (“CDS” as developed by SAP SE, Walldorf, Germany), etc.

In some implementations, the deployment infrastructure can use containers and/or container models for the purposes of deploying database objects. A container can correspond to a database schema. Containers can be used for multiple deployments of the same database artifacts, for development sandboxes, etc. Containers can be isolated from each other by various database mechanisms, e.g., each database schema with its deployed database objects can be owned by a per-schema technical database user. In some implementations, a cross-container access at the database level can be permitted (via database privileges) and/or prohibited.

In some implementations, database objects can be written in a schema-free way (e.g., no explicit schema references) to allow deployment of the same database objects into different containers. References to schema-external objects can be created using synonyms (or table links in case of zero-downtime maintenance (“ZDM”)), which can be bound during deployment. The synonyms (or table links) can provide schema-local names for the schema-external objects. Privileges on these schema-external objects can be explicitly granted to the container's technical user (e.g., SELECT-WITH-GRANT-OPTION privileges on schema-external ERP tables).

As stated above, the deployment infrastructure can be a layer on top of the HANA database. For the purposes of creating, modifying, and/or deleting objects inside the database, the deployment infrastructure can use structured query language (“SQL”) commands.

In some implementations, the deployment infrastructure can allow modeling of a networked set of persistence objects (e.g., tables, sequences, etc.), views, procedures, functions, data flows, etc. that can be later deployed. These objects can be converted into file-based artifacts, which can simplify dependency-based deployment, re-deployment, and/or undeployment of objects. It can also facilitate lifecycle management aspects, such as transport of objects. File-based artifacts can also allow separation of uploading of the artifacts into deployment infrastructure (i.e., staging), and deployment of the artifacts. Additionally, the artifacts can simplify incremental deployment scenarios where only modified files can be uploaded. The file artifacts can represent the target state of the database objects, e.g., they specify a view definition in a declarative way (for example, instead of imperative CREATE, ALTER, DROP statements).

In some implementations, the deployment infrastructure can perform dependency management by extracting a set of provided and/or required database (i.e., runtime) objects from the file artifacts and can use this information for dependency management during deployment (e.g., to calculate the order in which the database objects need to be created, and/or to detect missing, required objects). Additionally, dependencies can be used to re-deploy database objects that are affected by newly deployed or modified objects.

In some implementations, the deployment infrastructure can use database mechanisms to ensure a transactional all-or-nothing deployment. Modifications of database objects, operations, as well as re-deployments of affected artifacts can be performed inside a single database transaction. In some implementations, a single deployment can operate on a single container with the container boundary being a deployment boundary. For example, affected database objects inside other database schemata are not re-deployed and deployment does not fail if database objects inside other schemata break.

Further, in addition to the schema-based containers, the deployment infrastructure also can use database schemata to isolate its metadata, e.g., to separate storage of file artifacts from the deployed database objects.

In some implementations, the deployment infrastructure can implement build plugins to provide the infrastructure for all deployment aspects. The interpretation of artifacts including the extraction of dependencies and the steps to implement a target-state-based deployment of the artifacts can be performed by such build plugins, which can include, for example, a plugin for a table artifact type, a plugin for a view artifact type, etc. Build plugins can have access to the deployment container (for example, via a SQL-based application programming interface (“API”)). In some exemplary implementations, SQL commands that the build plugins need for creating/altering/dropping a database object can be available at the SQL layer of HANA. In addition, these SQL commands can further account for database security constraint and support the deployment infrastructure's transactional deployment, where statements are run inside a single database transaction in non-auto-commit mode.

In some implementations, the deployment infrastructure can be constrained by at least one of the following deployment architectural boundaries: database services, application programming interfaces, and technical users. In some exemplary implementations, the database service instances can be created via a database-specific service broker, e.g., a HANA database service broker. Additionally, a database service instance can correspond to a single database schema and an assigned technical database user. The HANA database service broker can delegate schema creation to the deployment infrastructure, such that the deployment infrastructure can also create its required metadata, database users, and/or database roles inside the database. On deletion of a database service instance, the deployment infrastructure can be called implicitly by the broker in order to delete the container schema, its metadata, etc.

In some implementations, an SQL-based application programming interface can be a lowest common denominator for the deployment infrastructure's API. It can be an API which is accessible via a standard HANA SQL connection.

A technical user can be a technical deployment user for a specific schema-based container. Deployment-related activities, e.g., staging of files, triggering of real deployment into a single container, etc., can be performed by a dedicated technical deployment user. The technical deployment user of the container schema can be different from the technical runtime user of the container schema to allow separation of privileges for deployment and/or runtime access to the deployed database objects.

I. Deployment Infrastructure

FIG. 1 illustrates an exemplary system 100 that can implement a deployment infrastructure, according to some implementations of the current subject matter. The system 100 can include a database cluster 102 (e.g., a HANA cluster), a deployment infrastructure client component 104, an extended services development infrastructure component 106, an extended services deployment component 108, as well as any other components that can be communicatively coupled with the database cluster 102. The components 104-110 can represent technical users that can access the database cluster 102 using, for example, a structured query language.

The database cluster 102 can include various database processes 112, 114 (e.g., HANA database processes), each having a design-time and runtime persistence components (not shown in FIG. 1). As shown in FIG. 1, the database process 114 can include a database processor 118 (e.g., a HANA SQL processor) that can be communicatively coupled to a deployment infrastructure proxy component 120. The deployment infrastructure proxy component 120 can be communicatively coupled to a deployment infrastructure process 116. The deployment infrastructure process 116 can include a deployment infrastructure kernel 122 (e.g., a HANA deployment infrastructure kernel) and at least one design-time build plugin component 124.

In some implementations, the technical users 104-110 can access the deployment infrastructure proxy component 120 via the database processor 118. The proxy component 120 then communicates with the kernel 122 via a network protocol connection. The kernel 122 accesses design-time build plugin(s) 124 to generate/create/modify various objects, which are then supplied by the kernel to the database processor 118 and can, thereafter, be persisted by the database processor 118.

In some implementations, the system 100 can provide an SQL-based API for the deployment infrastructure that can be accessed via a standard SQL connection, where the API can be exposed at the SQL layer. As shown in FIG. 1, system 100 can represent the system's target architecture for the deployment infrastructure in order to provide the API at the SQL layer and keep the deployment infrastructure kernel 122 and the deployment infrastructure design-time build plugin(s) 124 isolated in its own operation system process.

For the purposes of decoupling, the deployment infrastructure can provide database procedures for its APIs. Communication from the database process 114 (also referred to as hdbindexserver) towards the deployment infrastructure process 116 (also referred to as hdbdiserver) can be provided via a deployment infrastructure proxy library which can be loaded into the database process 114. This proxy can implement database procedures and/or client-side of a deployment infrastructure network protocol. All incoming requests can be routed to the deployment infrastructure process using this network protocol. In some implementations, the components 122 and 124 can also be inside the database process 114.

The deployment infrastructure process 116 can communicate to the database process 114 via an internal application programming interface (e.g., HANA's internal EAPI Thin Layer SQL client) on a new database transaction. This new transaction is not related to the database transaction in which the deployment infrastructure command is sent to the database process 114. The SQL communication from deployment infrastructure towards the database process 114 can be a trusted communication which can allow deployment infrastructure to execute SQL statements on behalf of different technical users inside a single database transaction in order to implement different security features at the database layer.

II. Deployment Infrastructure Containers

In some implementations, the deployment infrastructure can use schema-based containers, which can be database service instances which can correspond to a database schema and a set of technical users. The database broker can call the deployment infrastructure to create the application's container schema and its required metadata (e.g., companion schemata, technical users, etc.) via deployment infrastructure's container management API.

A single deployment via the deployment infrastructure can operate on one schema-based container. If multiple schemata are involved, then multiple deployments via the deployment infrastructure can be implemented, i.e., one for each schema. In case of ZDM, each data schema and each access schema can be considered a separate schema which can be deployed using its own deployment.

FIG. 2 illustrates an exemplary container 200 in a database schema, according to some implementations of the current subject matter. The container 200 can include a container runtime user 202 (e.g., container S runtime user (“RU-S”)), a container schema 204 (e.g., container S schema (“S”)), other schema(s) 206, a container object owner 208 (e.g., container S object owner (“COO-S”)), and a container schema owner 210 (e.g., container S schema owner (“CSO-S”)). The container schema can include a view object 212, a table object 214, and a synonym object 216. The synonym 216 can link to a table 218 in an external schema 206.

FIG. 3 illustrates exemplary multiple container system 300 in a database schema, according to some implementations of the current subject matter. The system 300 can include container schemas 304 and 314 (e.g., container S schema (“S”) and container T schema (“T”), respectively), other schemas 306, 316, container object owners 308, 318 (e.g., container S object owner (“COO-S”) and container T object owner (“COO-T”), respectively). The container schema S 304 can include a view object 312, a table object 314, and a synonym object 316. The synonym 316 can link to a table 318 in an external schema 306. Likewise, the container schema T 314 can include a view object 322, a table object 324, and a synonym object 326. The synonym 326 can link to a table 328 in an external schema 316.

A. View

Referring back to FIG. 2, the view 212 can be associated with a view plugin that can transform a design-time view resource into a SQL view database object. In some exemplary implementations, the file format can use a data definition language (“DDL”)-style syntax, which can be equivalent, for example, to the corresponding CREATE VIEW SQL syntax (without the “CREATE”). This can include support for column views of TYPE HIERARCHY if the query is provided as a SQL query. If the view selects from a synonym which points to an object inside another schema or different container or to an object inside the same container which is owned by a different user, then the container's object owner (i.e., COO-S 208) can be granted the required privileges on the target object, e.g., SELECT, UPDATE, INSERT, in order to access the object. For views, the object owner can also have WITH GRANT OPTION privileges (if the views are exposed to other users). If a view has to be secured via analytic privileges/structured privileges, then the view defined needs to contain the WITH STRUCTURED PRIVILEGE CHECK clause.

In some implementations, the deployment infrastructure can have at least one view plugin, which can include at least one of the following: a calculation view plugin, a projection view plugin, and/or any other view plugins. The calculation view plugin can transform a design-time calculation view description into a set of view database objects.

The projection view plugin can transform a design-time projection view resource into a projection view database object. A projection view configuration resource can contain a binding from the projection view to a target database, a target schema, and/or a target object (similar to synonyms, as discussed below). The definition of a projection view can include two design-time files: a projection view file (with an optional default configuration) and an explicit configuration of the projection view's target. The explicit configuration can be provided at deployment time, overriding an optional default configuration. An administrator can map object references according to the deployment context. In some exemplary implementations, the format of the projection view file can use a DDL-style syntax which can be equivalent to the corresponding CREATE PROJECTION VIEW SQL syntax (without the “CREATE”). The FROM clause of the PROJECTION VIEW definition can define the default configuration. A projection view configuration file can contain multiple configurations. If the “schema” of a target description is left out, then the projection view can point to a container-local object. In this case, the referenced object can be considered as a deployment dependency. If the projection view points to an object inside another schema or different container or to an object inside the same container, which is owned by a different user, then the container's object owner (e.g., COO-S 208 shown in FIG. 2) can be granted the required privileges on the target object, e.g., SELECT, UPDATE, INSERT, in order to access the object.

B. Table

The deployment infrastructure can also include a table 214 plugin that can transform a design-time table resource into a table database object. The file format can use a DDL-style syntax, which, in some exemplary implementations, can be equivalent to the corresponding CREATE TABLE SQL syntax (without the “CREATE”). Tables can have at least two types: ROW and COLUMN. A table can be self-contained. In some implementations, a table cannot reference another table.

The deployment infrastructure can include a virtual table plugin that can transform a design-time virtual table resource into a virtual table database object. The target database where the virtual table points to needs to be available via a database remote source. A definition of a virtual table can include two design-time files: a virtual table file (with an optional default configuration) and an explicit virtual table configuration that contains the binding from virtual table to remote source, target database, target schema, and/or target object. The explicit configuration can be provided at latest at deployment time, overriding the optional default configuration. An administrator can map object references according to the deployment context. In some exemplary implementations, the file format can use a DDL-style syntax which is equivalent to the corresponding CREATE VIRTUAL TABLE SQL syntax (without the “CREATE”). The container's object owner (e.g., COO-S 208 as shown in FIG. 2) can be granted the CREATE VIRTUAL TABLE ON REMOTE SOURCE privilege on the remote source in order to access the remote source.

C. Synonym

The synonym objects 216 or table links can allow referencing of schema-external objects. A typical example can include accessing database objects that are not brought into the system via HANA deployment infrastructure, e.g., database objects from an enterprise resource planning (“ERP”) system and/or replicated objects. These objects can be easily accessed by defining synonyms. In most cases, fully qualified names of referenced database objects are not known during development but can depend on deployment decisions. Thus, the synonym can include two design-time files: a declaration (with an optional default configuration) and an explicit configuration of the synonym's target. The explicit configuration can be provided at deployment time and can override an optional default configuration. Hence, an administrator can map object references according to the deployment context.

The following code illustrates an exemplary synonym definition and configuration. Here, the synonym definitions use the content of the associated “target” objects as a default configuration:

{  ″<synonym 1>″: {   ″target″: {    ″database″ : ″<the target database>″, // optional    ″schema″ : ″<the target schema>″, // optional    ″object″ : ″<the target object>″   }  },  ″<synonym 2>″: {   ″target″: {    ″database″ : ″<the target database>″, // optional    ″schema″ : ″<the target schema>″, // optional    ″object″ : ″<the target object>″   }  }, <...> }

In some implementations, a synonym definition/configuration file can contain multiple definitions/configurations. If the “schema” and/or the “database” of a target description is/are left out, then the synonym can point to a container-local object. In this case, the referenced object can be considered as a deployment dependency. If the “schema”/“database” of a target description is defined, then the referenced target object can be considered as a non-development-infrastructure-managed runtime object and it is not considered during dependency management. If the synonym points to an object inside another schema or different container or to an object inside the same container which is owned by a different user, then the container's object owner (i.e., COO-S 208 as shown in FIG. 2) can be granted the required privileges on this target object, e.g. SELECT, UPDATE, INSERT, in order to access the object. If views or definer-mode procedures are built on top of synonyms, then the object owner can be granted privileges WITH GRANT OPTION (if the views are exposed to other users).

III. Deployment Infrastructure Application Programming Interface

To perform container management and deployment, the deployment infrastructure can use two kinds of APIs. One of the APIs can include a higher-level privileged container management API that can allow creation and/or deletion of schema-based containers. The other API can include a container-level deployment API that can allow applications and/or tools to deploy/undeploy artifacts within a container.

FIG. 4 illustrates an exemplary deployment API system 400, according to some implementations of the current subject matter. The system 400 can include a container deployment user 402 (e.g., container S deploy user (“DU-S”)) and a deployment infrastructure's deployment API 404 (e.g., deployment API for S (“DA-S”) for a container (e.g., container 204, as shown in FIG. 2)). The deployment API 404 can include one or more API procedures 406. In some implementations, a deployment API can be paired to a container schema and can allow write/read design-time artifacts, trigger deploy/undeploy actions.

A. Container Management API

FIG. 5 illustrates an exemplary system 500 for performing deployment infrastructure administration and container management, according to some implementations of the current subject matter. Container management can be performed using one or more APIs, which can include one or more database procedures that can be executed via a central database schema for the deployment infrastructure (DI): _SYS_DI. Some of the common procedures for performing container management can include creation/dropping of a container, granting/revoking of privileges on a container scheme (e.g., schema S), granting/revoking privileges on the container deployment API:

-   -   _SYS_DI.CREATE_CONTAINER (creation of a container);     -   _SYS_DI.DROP_CONTAINER (dropping a container);     -   _SYS_DI.GRANT_CONTAINER_SCHEMA_PRIVILEGE (granting container         schema privilege);     -   _SYS_DI.REVOKE_CONTAINER_SCHEMA_PRIVILEGE (revoking container         schema privilege);     -   _SYS_DI.GRANT_CONTAINER_API_PRIVILEGE (granting container API         privilege);     -   _SYS_DI.REVOKE_CONTAINER_API_PRIVILEGE (revoking container API         privilege).

An exemplary grant of privileges on the container schema S can include a call _SYS_DI.GRANT_CONTAINER_SCHEMA_PRIVILEGE (‘S’, ‘SELECT’, ‘RUNTIME_USER_S’). An exemplary grant of a role on the container schema S can include a call of _SYS_DI.GRANT_CONTAINER_SCHEMA_ROLE (‘S’, ‘A_ROLE_XYZ’, ‘SOME_USER’). An exemplary grant of a privilege (e.g., WRITE, READ, MAKE) on the container S deployment API can include calls _SYS_DI.GRANT_CONTAINER_API_PRIVILEGE (‘S’, ‘WRITE’, ‘EXECUTE’, ‘DEPLOY_USER_S’); _SYS_DI.GRANT_CONTAINER_API_PRIVILEGE (‘S’, ‘READ’, ‘EXECUTE’, ‘DEPLOY_USER_S’); and _SYS_DI.GRANT_CONTAINER_API_PRIVILEGE (‘S’, ‘MAKE’, ‘EXECUTE’, ‘DEPLOY_USER_S’), respectively.

In some implementations, at installation time of the deployment infrastructure (together with underlying database appliance (e.g., HANA)), the management schema _SYS_DI, its content, and all internal deployment infrastructure system users can be created. Additionally, for bootstrapping of privileges, execute rights on these procedures (and/or select privileges on additional monitoring views, etc.) can be granted to the default administration user of the database with GRANT OPTION.

Referring to FIG. 5, the system 500 can include a database appliance 502 (e.g., HANA) communicatively coupled with extended services 504, which can be accessed by an extended services operator 540. The appliance 502 can include a container deployment infrastructure 506, a processor 508, a deployment infrastructure management component 526, and a management API 532. The container (e.g., container S) deployment infrastructure 506 can include deployment infrastructure plugin metadata for container S (“CP-S”) 510 along with an associated container S plugin metadata owner(s) (“CPO-S”) 516, a deployment infrastructure metadata and deployment API 512 for container S, including API procedure(s) 524, along with an associated container S metadata owner (“CMO-S”) 518, and a deployment schema/container (“S”) 514 along with container S schema owner (“CSO-S”) 520 and container S object owner (“COO-S”) 522 (which can have CREATE ANY privileges on the schema S). The container S can include one or more artifacts, objects, etc., as discussed above. The users 516, 518, 520, 522 are technical users. The deployment infrastructure management 526 can also be communicatively coupled with a deployment infrastructure transaction owner _SYS_DI_TO 528 and deployment infrastructure super user _STS_DI_SU 530 (which has all privileges). The database appliance 502 can also include a deployment infrastructure management API 532 having API procedure(s) 534 and a deployment infrastructure database object owner 536 that can be communicatively coupled with the management API 532, the API procedure(s) 534 as well as the API procedure(s) 524.

In some implementations, an administrator can create a deployment infrastructure technical management user (“TMU-HDI”) 542 and grant execute rights on the above procedures (e.g., create container, drop container, grant privilege, etc.) to the management user 542. The database service broker 538 of the extended services 504 can use the management user 542 to create/alter/drop containers and/or grant/revoke privileges to/from users. More than one management user can exist in the system 500, and the privileges can be assigned to various roles and/or various roles can be assigned to users. Further, grant/revoke database procedures can be provided which can support user privileges on the _SYS_DI schema and/or a container's metadata schemata.

In some implementations, when creating a container, the system 500 can implement the following procedures. On creation of a container schema S, the deployment infrastructure can create the technical container schema owner CSO-S 520, the container schema S 514, the container object owner COO-S 522, the metadata and deployment API companion schema CM-S 512, and a set of plugin metadata companion schemata CP-S 510 with corresponding owner users CPO-S(s) 516. The metadata schema CM-S 512 can be used for storing file artifacts and/or keeping track of active files. The container-specific plugin metadata schemata CPO-S(s) 516 can be used for build-plugin-specific metadata that can be used during deployment.

In some implementations, technical container users (i.e., users 510, 516, 518, 522, 528, 530, 536) can only be used internally by the deployment infrastructure and can be created as restricted database users without an ability to log-on to the database. The users also own their corresponding objects in the deployment infrastructure.

In some implementations, the container object owner COO-S 522 can be used for creating database objects inside the container schema S 514. For example, the user 522 can have CREATE ANY privileges on the container schema S 514 and the _SYS_DI_OO_DEFAULTS role. This way, the database objects are owned by a system-internal technical user and are not bound to the lifetime of externally owned users which trigger the deployment of artifacts. Additionally, the deployed database objects do not inherit database privileges from the deploying users. The _SYS_DI_OO_DEFAULTS role can give privileges on standard database objects, e.g., objects in SYS like SYS.DUMMY. The _SYS_DI_OO_DEFAULTS role can be a deployment infrastructure specific variant of the PUBLIC role (which can have a plurality of privileges) with a minimal set of object privileges that every container object owner can have.

In some implementations, the objects are not created via the container schema owner CSO-S 520 in order to avoid accidental deletion of objects inside the schema which were created by other users (e.g., by applications at runtime). The container object owner COO-S 522 does not have execute rights on the container's deployment API procedures. Thus, it might be not possible to deploy definer mode procedures which expose and/or use the deployment API (without explicitly granting these privileges to the container object owner COO-S). The container object owner COO-S 522 does not have any access to the metadata schemata.

Further, database privileges on external objects, e.g., SELECT privileges on ERP tables, which the container object owner COO-S 522 needs when creating database objects on top of these external objects (e.g. when deploying a view), can be granted to the object owner by the privilege owner (e.g., an administrator). If a view should be created by the container object owner COO-S 522, then the privileges on the external objects can be granted with GRANT OPTION.

The container schema owner CSO-S 520 can be used for dropping the container schema S 514 when the container is deleted. The container schema owner 520 can drop the schema including all contained database objects, although database objects from other users might exist inside the schema. The container schema owner CSO-S 520 can be used internally by deployment infrastructure for granting/revoking schema-level privileges to/from users.

In some implementations, once containers are created, they can be provided with a particular name in accordance with a container naming scheme. For example, container names can have a maximum size of 64 characters and can contain characters A to Z, numbers 0 to 9, and an underscore character “_”, and/or any other characters.

The name of the container schema S 514, the name of the deployment API and metadata schema CM-S 512, and the name of the container object owner COO-S 522 can be visible to administrators and/or end-users. Thus, as shown in FIG. 5, they can be named “S”, “S#DI”, and “S#OO”. All other internal users and internal schemata can use a prefix “_DI#S#” to allow to group and/or hide them in tools/queries/etc.

B. Container-Level Deployment API

FIG. 6 illustrates an exemplary system 600 having container-level deployment application program interfaces, according to some implementations of the current subject matter. The system 600 can include a database 602 (e.g., HANA) communicatively coupled to extended services 604, which in turn, can be accessed by the extended services operator 640. The extended services user 640 can perform various functions, including, for example, install, upgrade, scale, etc. The extended services 604 can include an application deployment component 637 and an application runtime component 639, which can be used for deployment and runtime of an application, respectively.

The database 602 can include a processor (e.g., a HANA SQL processor) 608, container deployment infrastructure 606, in addition to deployment infrastructure for deployment of a container (e.g., container S) 626, a pseudo-catalog metadata (e.g., _SYS_DI_BIMC*) 632, and various other schema (e.g., other application schema, ERP schema, etc.) 636. The container (e.g., container S) deployment infrastructure 606 can include deployment infrastructure plugin metadata for container S (“CP-S”) 610 along with an associated container S plugin metadata owner(s) (“CPO-S”) 616, a deployment infrastructure metadata and deployment API 612 for container S, including API procedure(s) 624, along with an associated container S metadata owner (“CMO-S”) 618, and a deployment schema/container (“S”) 614 along with container S schema owner (“CSO-S”) 620 and container S object owner (“COO-S”) 622 (which can have CREATE ANY privileges on the schema S). In some implementations, the container object owner 622 can also receive access rights (e.g., explicitly granted by a third party) to other application schema component 636. The users 616, 618, 620, 622 can be technical users in accordance with the discussion above.

In some implementations, the application deployment component 637 can be associated with a container S deploy user (“DU-S”), which can generate various calls (e.g., CALL DA-S.WRITE ( . . . ), CALL DA-SMAKE ( . . . ), etc.) to the processor 608. Similarly, the application runtime component 639 can be associated with a container S runtime user (“RU-S”), which execute various procedures (e.g., SELECT, INSERT, etc.) during runtime of an application, where the execution calls can be sent to the processor 608 for processing.

During deployment, calls issued by the application deployment component 637 can be passed on to the API procedure component 624 in the deployment infrastructure's metadata and deployment API component 612. The CM-S component 624 can further pass the call to the deployment infrastructure's deployment component 626. The deployment component 626 can exchange metadata updates and perform file staging updates using metadata object owner (“MOO-S”) and/or container metadata schema owner (“MSO-S”), which can be other technical users in the system 600. The metadata can be container-specific metadata (e.g., design-time container (“DTC”)) and can include information concerning design-time artifacts, data dependencies and/or build plugin metadata, as well as any other information. The deployment component 626 can also communicate with the deployment schema container component 614 to perform deployment/undeployment of schema/container using COO-S 622. The component 626 can further be controlled by the transaction owner component 628 (another technical user). In some implementations, the component 626 can also exchange pseudo-catalog metadata updates with the pseudo-catalog metadata component 632 using catalog metadata user 630 (e.g., using _SYS_DI_*CATALOG).

In some implementations, APIs for working with a specific container S 614 can be created as database procedures inside the container deployment API schema CM-S (i.e., “S#DI”) 612. The procedures can include at least one of the following: file-system operations, make operations, grant/revoke operations. The file-system operation can include at least one of the following: CM-S.WRITE, CM-S.READ, CM-S.READ_DEPLOYED, CM-S.LIST, CM-S.LIST_DEPLOYED, CM-S.STATUS, and others. The make operations can include CM-S.MAKE and other procedures. The grant/revoke operations can include at least one of the following: CM-S.GRANT_API_PRIVILEGE, CM-S.REVOKE_API_PRIVILEGE, CM-S.GRANT_(—)SCHEMA_PRIVILEGE, CM-S.REVOKE_SCHEMA_PRIVILEGE, CM-S.GRANT_SCHEMA_ROLE, CM-S.REVOKE_SCHEMA_ROLE, and others.

The above database procedures can be created as definer mode procedures and can be owned by the deployment infrastructure database object owner _SYS_DI. Their definition can include a delegation to a corresponding procedure in the central management schema _SYS_DI while binding the deployment schema. For example:

PROCEDURE CM-S.MAKE (a, b, c, d) . . .

BEGIN

-   -   --bind container name to ‘S’ and call private procedure         _SYS_DI.MAKE_CALL_SYS_DI.MAKE_(‘S’, a, b, c, d);

END

Execution rights for the container-level deployment APIs for schema S can be explicitly granted after container creation, using _SYS_DI.GRANT_CONTAINER_API_PRIVILEGE and/or with GRANT OPTION.

After creation of container S, the operator 640 can create at least the following users: the deploy user DU-S 641 and the runtime user RU-S 643. Then, the operator 640 can grant privileges on the container's deployment API to the deploy user DU-S 641 and privileges on the container schema S to the runtime user RU-S 643. Additional users and privileges can also be created. In some implementations, the deploy user and the runtime user can be a single entity, however, having separate deploy user DU-S 641 and runtime user RU-S 643 can simplify zero-downtime maintenance (“ZDM”) upgrades. For example, during a ZDM upgrade, ZDM can set the runtime user RU-S 643 into a read-only mode by revoking privileges which can modify the data in the container schema S from the runtime user RU-S 643, while allowing the deploy user DU-S 641 to create/delete database objects as part of the upgrade.

In some implementations, a deployment user can be allowed to deploy everything in the given schema-based container. This can avoid a situation where the deployment user is limited to deploying a certain kind of artifact type and/or database objects that have a certain kind of name.

In some implementations, the current subject matter's deployment infrastructure can also provide various deployment privilege workarounds. This can be applicable in situation where not all database rights which are required during deployment into a container schema S currently exist as a database privilege, are grantable and/or restrictable on a schema-level (e.g., they exist only as a global privilege), and/or are contained in the schema-level CREATE ANY privilege. In order to work around these limitations without granting permanent system-wide privileges to the container object owner COO-S, the deployment infrastructure can implement a special deployment infrastructure internal super user _SYS_DI_SU user (e.g., super 530 as shown in FIG. 5), which can be created at installation time and who has all the required privileges (e.g., creation of users, creation of roles, etc.). When the deployment transaction begins, the super user 530 can temporarily grant one or more privileges to the container object owner COO-S, and when a transaction is going to be committed, these privileges can be revoked by the super user 530. This approach can be used whenever the container object owner must be the owner of the created database objects and can ensure that the container object owner COO-S has the required privileges at the point in time when the container object owner issues the CREATE statements towards the database. In some implementations, a catalog read access and/or dropping of database objects where only a system-wide privilege is available, can be performed directly via the super user 530. Further, insertion/deletion of data into/from catalog-like metadata tables which do not have schema-level privileges can be performed via dedicated “catalog” users (e.g., catalog metadata user 630 as shown in FIG. 6) and can be hidden behind corresponding APIs.

Exemplary container management APIs and container-level APIs can be found in the Appendix A. The container management APIs can be available via the central database schema _SYS_DI and the APIs for a specific container S inside the container's API schema S#DI. The APIs can include a set of database procedures, table types, and/or monitoring views.

IV. Technical Users

FIG. 7 illustrates an exemplary system 700 that can use different technical users during deployment (such as during a single transaction), according to some implementations of the current subject matter. System 700 can include a deployment infrastructure component 710, a deployment infrastructure deployment component for a container S 720, and design-time (“DT”) plugins 730. The component 710 can include a design-time container metadata for container S (“CM-S”) 704, a plugin metadata storage for container S (“CPOx-S”) 706, and deployment schema/container S (“S”) 708. The deployment component 720 can include the design-time container (“DTC”) API 722. In some implementations, the deployment process of a deployment container/schema S 708 can be orchestrated by a make component 725. The make component 725 can read design-time artifacts for deployment from the container metadata schema 704 via the design-time container API 722. In some implementations, the make component 725 can pass the design-time artifacts to the corresponding design-time plugins 730. The design-time plugins 730 can create database objects in the deployment schema/container S 708, e.g., tables, views, etc., via the database run-time container access (“DB RTC”) API 726. In addition, the design-time plugins 730 can store metadata within the plugin metadata storage for container S 706. In some implementations, the design-time plugins 730 can also create business intelligence (“BI”) metadata in the BI metadata catalog (“BIMC”) 736. In some implementations, the design-time plugins 730 can also create core data services (“CDS”) metadata in the CDS metadata catalog 734. In some implementations, the design-time plugins 730 can also create search metadata in the search metadata catalog 737.

As shown in FIG. 7, the system 700 can include one or more technical users that can perform various functions associated with the deployment infrastructure. A user SYS_DI_BI_CATALOG 744 can be used for the BI metadata catalog (read/write access to _SYS_BI.BIMC_*), where DB RTC API 728 can be used. A user _SYS_DI_CDS_CATALOG 742 can be used for the CDS metadata catalog (read/write access to _SYS_RT.CDS_*), where DB RTC API 732 can be used. A user _SYS_DI_SEARCH_CATALOG 745 can be used for the search metadata catalog 737 (_SYS_RT.SEARCH_* and _SYS⁺ RT.ESH_*), where DB RTC API 729 can be used. The search metadata catalog can be used to store metadata for database-level search features. A user _SYS_DI_CATALOG 747 can be used for generic catalog queries, where DB RTC API 731 can be used. The database catalog user _SYS_DI_CATALOG 747 can be used for unfiltered generic queries on the database catalog, e.g., to retrieve metadata of tables, e.g., field names, field types, field sizes, etc.

In some implementations, the container object owner COO-S 718 can have extended privileges during the deployment process and thus, it should not be possible for build plugins to call arbitrary database procedures during deployment. Access to required database-internal database procedures can be provided via dedicated methods of the deployment infrastructure's database interface.

In some implementations, a common naming approach can be implemented by the deployment infrastructure. For example, .hdinamespace can contain a pattern that describes the naming scheme (e.g., a scheme “dot-and-double-colon, casesensitive” for “name.space::object”, a “underscore, sql-style” for “name space object”, or a “none” scheme for you-get-what-you-write). This pattern can be checked by the build plugins to ensure that the created database objects follow the rule of the pattern. The .hdinamespace files can be created on a folder-level, so it is possible to have a mixture of naming schemes inside a single container.

In some implementations, build plugins can be handled as pluggable components, e.g., each build plugin can live inside its own shared library and plugins can be loaded by the deployment infrastructure dynamically.

V. Deployment of Database Objects

In some implementations, the deployment infrastructure can be used to deploy artifacts and/or objects in a particular order. The deployment of objects can be based on dependencies between objects in the target model. The order of deployment of artifacts can be based on information about database runtime objects, which can be provided by an artifact and/or which can be required by an artifact. Using this information, a dependency graph can be created, which can connect object providers to corresponding object consumers.

FIG. 8 illustrates an exemplary graph 800 of artifacts and objects, according to some implementations of the current subject matter. The graph 800 can include artifacts A 802, B 804, and C 806. The artifact A 802 can provide an object a 812; artifact B 804 can provide an object b 814; and artifact C 806 can provide an object c 816. Additionally, artifact B 804 can require object a 812 and artifact C can require objects a 812 and b 814. The artifacts and objects can be tables, views, procedures, etc. that can be contained in the database. For example, a table requiring insertion of additional fields, columns, etc. can be deployed by defining a table (e.g., table A definition), defining a view (e.g., view B definition), uploading the definitions into the deployment infrastructure, and deploying table A and view B. This process can also involve determining any dependencies that may be required (e.g., objects that the table may require, objects on which the view may depend, etc.). The plugins can be used to determine the order of deployment of the table A and view B.

In some implementations, the artifacts can have various types. In some cases, the three artifacts 802-806 can have the same artifact type (A=B=C), or three different types (A≠B≠C and A≠C), or two different types (A=B≠C, A≠B=C, or A=C≠B). In some implementations, a single build plugin can handle all artifact types. Alternatively, different build plugins can handle different artifact types.

FIG. 9 illustrates an exemplary dependency graph 900, according to some implementations of the current subject matter. The graph 900 is based on the artifacts 802-806 and objects 812-816 shown in FIG. 8. As shown in FIG. 9, dependency 902 illustrates a dependency between artifacts A 802 and B 804, i.e., artifact B requires object a. Dependency 904 illustrates a dependency between artifacts C 806 and B 804, i.e., artifact C requires object b. Dependency 906 illustrates a dependency between artifacts C 806 and A 802, i.e., artifact C requires object a. Artifact A does not depend on any other artifact.

FIG. 10 illustrates an exemplary execution graph 1000, according to some implementations of the current subject matter. The execution graph 1000 is generated based on the dependency graph 900 shown in FIG. 9 and illustrates an initial deployment of the three artifacts A, B, C, shown FIG. 8. As shown in FIG. 10, the first deployment 1002 (“DEPLOY A”) involves deploying artifact A 802. The second deployment 1004 (“DEPLOY B”) involves deploying artifact B 804. The third deployment 1006 (“DEPLOY C”) involves deploying artifact C 806.

In some implementations, the deployment process of artifacts can be modified by receiving a modified version of an artifact or undeploying an old artifact and receiving a modified artifact. Using the first or the “DEPLOY” strategy, the build plugin can receive a modified, new version of the artifact and thus, can react accordingly. For example, the build plugin can issue ALTER statements to the database. Using the second or “UNDEPLOY-DEPLOY” strategy, the old artifact can be undeployed and the build plugin receives the modified, new version of the artifact for deployment. In some implementations, modification strategies can be combined. Similar process can be applicable to revalidation of artifacts which can occur when artifacts that provide required objects are modified (or revalidated).

FIGS. 11a-d illustrate exemplary modification strategies, according to some implementations of the current subject matter. FIG. 11a illustrates an exemplary modification execution graph 1102 for modification of artifact A and revalidation of artifacts B and C. In this case, a build plugin for artifact A can use the second or “UNDEPLOY-DEPLOY” strategy to perform the modification, and the build plugins for artifacts B and C can use the “DEPLOY” strategy for revalidations. The modifications proceed as follows. First, artifact A is undeployed (“UNDEPLOY A”), then the modified artifact A′ is deployed (“DEPLOY A′”), and then artifacts B and C are (re)deployed (“(RE)DEPLOY B” and “(RE)DEPLOY C”). The redeployment of artifacts B and C is performed because artifact A has been changed to artifact A′.

FIG. 11b illustrates an exemplary modification execution graph 1104 for modification of artifact A and revalidation of artifacts B and C. In this case, all build plugins use the “UNDEPLOY-DEPLOY” strategy (for modifications and revalidations). The modifications proceed as follows. First artifact C is undeployed (“UNDEPLOY C”), then artifact B is undeployed (“UNDEPLOY B”), and then artifact A is undeployed (“UNDEPLOY A”). Once the undeployments are completed, a modified artifact A′ is deployed (“DEPLOY A′”). This is followed by redeployment and revalidation of unmodified or original artifacts B and C (“(RE)DEPLOY B” followed by “(RE)DEPLOY C”)).

FIG. 11c illustrates an exemplary modification execution graph 1106 for modification of artifact A and revalidation of artifacts B and C. In this case, the build plugin for the modified artifact A′ uses the “DEPLOY” strategy for modifications, and the other plugins use the “UNDEPLOY-DEPLOY” strategy for revalidations. The modification proceeds as follows. First, artifacts C and B are undeployed (“UNDEPLOY C” followed by “UNDEPLOY B”). Then, new artifact A′ is deployed (“DEPLOY A′”). Once the new artifact A′ is deployed, the artifacts B and C are redeployed/revalidated (“(RE)DEPLOY B” followed by “(RE)DEPLOY C”)).

FIG. 11d illustrates an exemplary modification execution graph 1108 for modification of artifact A and revalidation of artifacts B and C. In this case, all involved build plugins always use the “DEPLOY” strategy (for modifications and revalidations). As shown in FIG. 11d , first, new artifact A′ is deployed (“DEPLOY A′”) and then artifacts B and C are redeployed/revalidated (“(RE)DEPLOY B” followed by “(RE)DEPLOY C”)).

The deployment infrastructure can also prevent occurrences of various cyclic dependencies. For example, if artifact C depends on artifact B, and artifact B depends on artifact C, then no execution order for the deployment of B and C can be determined, as shown by the execution graph 1202 in FIG. 12a . This is because both artifacts require that the other artifact is deployed before the other one is deployed as well.

However, in some cases, cyclic dependencies can be allowed. FIG. 12b illustrates an execution graph 1204 that allows cyclic dependencies between artifacts. In this case, artifacts B and C can have the same artifact type and thus can be handled by the same build plugin, which allows cycles for its artifacts. Hence, the cycle between artifacts B and C is an intra-type-cycle and is not considered as a cycle for the purposes of execution graph creation. Artifacts A and B can be passed together to the build plugin and the intra-type-cycle between artifacts B and C can be handled by the build plugin, which can determine whether the cycle cannot be permitted.

FIG. 12c illustrates an execution graph 1206 that allows cyclic dependencies. In this case, a modified artifact B′ and artifact C can be cyclically-dependent (in view of a cyclic dependency between the original artifact B and artifact C) and can be passed together to the build plugin, which can handle the modification and the cyclic dependency. The build plugin can no longer request different behavior for modifications and revalidations, because both situations can be handled as modifications in the execution graph.

VI. High Performance Analytic Appliance

In some implementations, the current subject matter can be implemented in various in-memory database systems, such as a High Performance Analytic Appliance (“HANA”) system as developed by SAP SE, Walldorf, Germany. Various systems, such as, enterprise resource planning (“ERP”) system, supply chain management system (“SCM”) system, supplier relationship management (“SRM”) system, customer relationship management (“CRM”) system, and/or others, can interact with the in-memory system for the purposes of accessing data, for example. Other systems and/or combinations of systems can be used for implementations of the current subject matter. The following is a discussion of an exemplary in-memory system.

FIG. 13 illustrates an exemplary system 1300 in which a computing system 1302, which can include one or more programmable processors that can be collocated, linked over one or more networks, etc., executes one or more modules, software components, or the like of a data storage application 1304, according to some implementations of the current subject matter. The data storage application 1304 can include one or more of a database, an enterprise resource program, a distributed storage system (e.g. NetApp Filer available from NetApp of Sunnyvale, Calif.), or the like.

The one or more modules, software components, or the like can be accessible to local users of the computing system 1302 as well as to remote users accessing the computing system 1302 from one or more client machines 1306 over a network connection 1310. One or more user interface screens produced by the one or more first modules can be displayed to a user, either via a local display or via a display associated with one of the client machines 1306. Data units of the data storage application 1304 can be transiently stored in a persistence layer 1312 (e.g., a page buffer or other type of temporary persistency layer), which can write the data, in the form of storage pages, to one or more storages 1314, for example via an input/output component 1316. The one or more storages 1314 can include one or more physical storage media or devices (e.g. hard disk drives, persistent flash memory, random access memory, optical media, magnetic media, and the like) configured for writing data for longer term storage. It should be noted that the storage 1314 and the input/output component 1316 can be included in the computing system 1302 despite their being shown as external to the computing system 1302 in FIG. 13.

Data retained at the longer term storage 1314 can be organized in pages, each of which has allocated to it a defined amount of storage space. In some implementations, the amount of storage space allocated to each page can be constant and fixed. However, other implementations in which the amount of storage space allocated to each page can vary are also within the scope of the current subject matter.

FIG. 14 illustrates exemplary software architecture 1400, according to some implementations of the current subject matter. A data storage application 1304, which can be implemented in one or more of hardware and software, can include one or more of a database application, a network-attached storage system, or the like. According to at least some implementations of the current subject matter, such a data storage application 1304 can include or otherwise interface with a persistence layer 1312 or other type of memory buffer, for example via a persistence interface 1402. A page buffer 1404 within the persistence layer 1312 can store one or more logical pages 1406, and optionally can include shadow pages, active pages, and the like. The logical pages 1406 retained in the persistence layer 1312 can be written to a storage (e.g. a longer term storage, etc.) 1314 via an input/output component 1316, which can be a software module, a sub-system implemented in one or more of software and hardware, or the like. The storage 1314 can include one or more data volumes 1410 where stored pages 1412 are allocated at physical memory blocks.

In some implementations, the data storage application 1304 can include or be otherwise in communication with a page manager 1414 and/or a savepoint manager 1416. The page manager 1414 can communicate with a page management module 1420 at the persistence layer 1312 that can include a free block manager 1422 that monitors page status information 1424, for example the status of physical pages within the storage 1314 and logical pages in the persistence layer 1312 (and optionally in the page buffer 1404). The savepoint manager 1416 can communicate with a savepoint coordinator 1426 at the persistence layer 1312 to handle savepoints, which are used to create a consistent persistent state of the database for restart after a possible crash.

In some implementations of a data storage application 1304, the page management module of the persistence layer 1312 can implement shadow paging. The free block manager 1422 within the page management module 1420 can maintain the status of physical pages. The page buffer 1404 can include a fixed page status buffer that operates as discussed herein. A converter component 1440, which can be part of or in communication with the page management module 1420, can be responsible for mapping between logical and physical pages written to the storage 1314. The converter 1440 can maintain the current mapping of logical pages to the corresponding physical pages in a converter table 1442. The converter 1440 can maintain a current mapping of logical pages 1406 to the corresponding physical pages in one or more converter tables 1442. When a logical page 1406 is read from storage 1314, the storage page to be loaded can be looked up from the one or more converter tables 1442 using the converter 1440. When a logical page is written to storage 1314 the first time after a savepoint, a new free physical page is assigned to the logical page. The free block manager 1422 marks the new physical page as “used” and the new mapping is stored in the one or more converter tables 1442.

The persistence layer 1312 can ensure that changes made in the data storage application 1304 are durable and that the data storage application 1304 can be restored to a most recent committed state after a restart. Writing data to the storage 1314 need not be synchronized with the end of the writing transaction. As such, uncommitted changes can be written to disk and committed changes may not yet be written to disk when a writing transaction is finished. After a system crash, changes made by transactions that were not finished can be rolled back. Changes occurring by already committed transactions should not be lost in this process. A logger component 1444 can also be included to store the changes made to the data of the data storage application in a linear log. The logger component 1444 can be used during recovery to replay operations since a last savepoint to ensure that all operations are applied to the data and that transactions with a logged “commit” record are committed before rolling back still-open transactions at the end of a recovery process.

To ensure that committed changes are not lost, redo log information can be written by the logger component 1444 whenever a change is made. This information can be written to disk at latest when the transaction ends. The log entries can be persisted in separate log volumes while normal data is written to data volumes. With a redo log, committed changes can be restored even if the corresponding data pages were not written to disk. For undoing uncommitted changes, the persistence layer 1312 can use a combination of undo log entries (from one or more logs) and shadow paging.

The persistence interface 1402 can handle read and write requests of stores (e.g., in-memory stores, etc.). The persistence interface 1402 can also provide write methods for writing data both with logging and without logging. If the logged write operations are used, the persistence interface 1402 invokes the logger 1444. In addition, the logger 1444 provides an interface that allows stores (e.g., in-memory stores, etc.) to directly add log entries into a log queue. The logger interface also provides methods to request that log entries in the in-memory log queue are flushed to disk.

Log entries contain a log sequence number, the type of the log entry and the identifier of the transaction. Depending on the operation type additional information is logged by the logger 1444. For an entry of type “update”, for example, this would be the identification of the affected record and the after image of the modified data.

When the data application 1304 is restarted, the log entries need to be processed. To speed up this process the redo log is not always processed from the beginning Instead, as stated above, savepoints can be periodically performed that write all changes to disk that were made (e.g., in memory, etc.) since the last savepoint. When starting up the system, only the logs created after the last savepoint need to be processed. After the next backup operation the old log entries before the savepoint position can be removed.

When the logger 1444 is invoked for writing log entries, it does not immediately write to disk. Instead it can put the log entries into a log queue in memory. The entries in the log queue can be written to disk at the latest when the corresponding transaction is finished (committed or aborted). To guarantee that the committed changes are not lost, the commit operation is not successfully finished before the corresponding log entries are flushed to disk. Writing log queue entries to disk can also be triggered by other events, for example when log queue pages are full or when a savepoint is performed.

With the current subject matter, the logger 1444 can write a database log (or simply referred to herein as a “log”) sequentially into a memory buffer in natural order (e.g., sequential order, etc.). If several physical hard disks/storage devices are used to store log data, several log partitions can be defined. Thereafter, the logger 1444 (which as stated above acts to generate and organize log data) can load-balance writing to log buffers over all available log partitions. In some cases, the load-balancing is according to a round-robin distributions scheme in which various writing operations are directed to log buffers in a sequential and continuous manner. With this arrangement, log buffers written to a single log segment of a particular partition of a multi-partition log are not consecutive. However, the log buffers can be reordered from log segments of all partitions during recovery to the proper order.

As stated above, the data storage application 1304 can use shadow paging so that the savepoint manager 1416 can write a transactionally-consistent savepoint. With such an arrangement, a data backup comprises a copy of all data pages contained in a particular savepoint, which was done as the first step of the data backup process. The current subject matter can be also applied to other types of data page storage.

In some implementations, the current subject matter can be configured to be implemented in a system 1500, as shown in FIG. 15. The system 1500 can include a processor 1510, a memory 1520, a storage device 1530, and an input/output device 1540. Each of the components 1510, 1520, 1530 and 1540 can be interconnected using a system bus 1550. The processor 1510 can be configured to process instructions for execution within the system 1500. In some implementations, the processor 1510 can be a single-threaded processor. In alternate implementations, the processor 1510 can be a multi-threaded processor. The processor 1510 can be further configured to process instructions stored in the memory 1520 or on the storage device 1530, including receiving or sending information through the input/output device 1540. The memory 1520 can store information within the system 1500. In some implementations, the memory 1520 can be a computer-readable medium. In alternate implementations, the memory 1520 can be a volatile memory unit. In yet some implementations, the memory 1520 can be a non-volatile memory unit. The storage device 1530 can be capable of providing mass storage for the system 1500. In some implementations, the storage device 1530 can be a computer-readable medium. In alternate implementations, the storage device 1530 can be a floppy disk device, a hard disk device, an optical disk device, a tape device, non-volatile solid state memory, or any other type of storage device. The input/output device 1540 can be configured to provide input/output operations for the system 1500. In some implementations, the input/output device 1540 can include a keyboard and/or pointing device. In alternate implementations, the input/output device 1540 can include a display unit for displaying graphical user interfaces.

FIG. 16 illustrates an exemplary method 1600, according to some implementations of the current subject matter. At 1602, a file (or a set of files) containing a plurality of artifacts for deploying during runtime of an application can be defined. Each artifact in the plurality of artifacts can include at least one object in the plurality of objects required to be deployed during runtime of the application. At 1604, at least one dependency for the artifact in the plurality of artifacts can be determined based on the file. At 1606, an execution order for deployment of the plurality of artifacts can be generated based on the determined dependencies. At 1608, the plurality of artifacts can be deployed in accordance with the generated execution order.

In some implementations, the current subject matter can include one or more of the following optional features. In some implementations, the deployment can include at least one of the following: undeploying the artifact, deploying a modified version of the artifact, and re-deploying the artifact.

In some implementations, the method can also include determining whether the artifact is cyclically dependent on another artifact in the plurality of artifacts, prohibiting deployment of the artifact and another artifact based on a determination that the artifact and another artifact do not belong to the same build plugin (where the plugin is used to deploy the artifact at runtime of the application), and permitting deployment of the artifact and another artifact based on a determination that the artifact and another artifact belong to the same plugin.

In some implementations, the method can include generating a dependency graph for the plurality of the artifacts based on the plurality of required objects, where the execution order is generated based on the generated dependency graph.

In some implementations, the deployment can include initially deploying, based on the generated execution order, the plurality of artifacts, modifying an artifact in the plurality of artifacts, generating a modified execution order, where the modified execution order specifies deployment of the modified artifact, and deploying the plurality of artifacts including the modified artifact based on the modified execution order. The method can also include determining another artifact in the plurality of artifacts being dependent on the artifact, and redeploying another artifact as a result of the modification of the artifact. The method can further include determining another artifact in the plurality of artifacts being dependent on the artifact, and undeploying another artifact prior to deploying the modified artifact, deploying the modified artifact, and redeploying another artifact after deploying the modified artifact.

In some implementations, the dependency can include at least one of the following: the artifact being dependent on at least another artifact in the plurality of artifacts and the artifact being independent of any artifact in the plurality of artifacts.

The systems and methods disclosed herein can be embodied in various forms including, for example, a data processor, such as a computer that also includes a database, digital electronic circuitry, firmware, software, or in combinations of them. Moreover, the above-noted features and other aspects and principles of the present disclosed implementations can be implemented in various environments. Such environments and related applications can be specially constructed for performing the various processes and operations according to the disclosed implementations or they can include a general-purpose computer or computing platform selectively activated or reconfigured by code to provide the necessary functionality. The processes disclosed herein are not inherently related to any particular computer, network, architecture, environment, or other apparatus, and can be implemented by a suitable combination of hardware, software, and/or firmware. For example, various general-purpose machines can be used with programs written in accordance with teachings of the disclosed implementations, or it can be more convenient to construct a specialized apparatus or system to perform the required methods and techniques.

The systems and methods disclosed herein can be implemented as a computer program product, i.e., a computer program tangibly embodied in an information carrier, e.g., in a machine readable storage device or in a propagated signal, for execution by, or to control the operation of, data processing apparatus, e.g., a programmable processor, a computer, or multiple computers. A computer program can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program can be deployed to be executed on one computer or on multiple computers at one site or distributed across multiple sites and interconnected by a communication network.

As used herein, the term “user” can refer to any entity including a person or a computer.

Although ordinal numbers such as first, second, and the like can, in some situations, relate to an order; as used in this document ordinal numbers do not necessarily imply an order. For example, ordinal numbers can be merely used to distinguish one item from another. For example, to distinguish a first event from a second event, but need not imply any chronological ordering or a fixed reference system (such that a first event in one paragraph of the description can be different from a first event in another paragraph of the description).

The foregoing description is intended to illustrate but not to limit the scope of the invention, which is defined by the scope of the appended claims. Other implementations are within the scope of the following claims.

These computer programs, which can also be referred to programs, software, software applications, applications, components, or code, include machine instructions for a programmable processor, and can be implemented in a high-level procedural and/or object-oriented programming language, and/or in assembly/machine language. As used herein, the term “machine-readable medium” refers to any computer program product, apparatus and/or device, such as for example magnetic discs, optical disks, memory, and Programmable Logic Devices (PLDs), used to provide machine instructions and/or data to a programmable processor, including a machine-readable medium that receives machine instructions as a machine-readable signal. The term “machine-readable signal” refers to any signal used to provide machine instructions and/or data to a programmable processor. The machine-readable medium can store such machine instructions non-transitorily, such as for example as would a non-transient solid state memory or a magnetic hard drive or any equivalent storage medium. The machine-readable medium can alternatively or additionally store such machine instructions in a transient manner, such as for example as would a processor cache or other random access memory associated with one or more physical processor cores.

To provide for interaction with a user, the subject matter described herein can be implemented on a computer having a display device, such as for example a cathode ray tube (CRT) or a liquid crystal display (LCD) monitor for displaying information to the user and a keyboard and a pointing device, such as for example a mouse or a trackball, by which the user can provide input to the computer. Other kinds of devices can be used to provide for interaction with a user as well. For example, feedback provided to the user can be any form of sensory feedback, such as for example visual feedback, auditory feedback, or tactile feedback; and input from the user can be received in any form, including, but not limited to, acoustic, speech, or tactile input.

The subject matter described herein can be implemented in a computing system that includes a back-end component, such as for example one or more data servers, or that includes a middleware component, such as for example one or more application servers, or that includes a front-end component, such as for example one or more client computers having a graphical user interface or a Web browser through which a user can interact with an implementation of the subject matter described herein, or any combination of such back-end, middleware, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication, such as for example a communication network. Examples of communication networks include, but are not limited to, a local area network (“LAN”), a wide area network (“WAN”), and the Internet.

The computing system can include clients and servers. A client and server are generally, but not exclusively, remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other.

The implementations set forth in the foregoing description do not represent all implementations consistent with the subject matter described herein. Instead, they are merely some examples consistent with aspects related to the described subject matter. Although a few variations have been described in detail above, other modifications or additions are possible. In particular, further features and/or variations can be provided in addition to those set forth herein. For example, the implementations described above can be directed to various combinations and sub-combinations of the disclosed features and/or combinations and sub-combinations of several further features disclosed above. In addition, the logic flows depicted in the accompanying figures and/or described herein do not necessarily require the particular order shown, or sequential order, to achieve desirable results. Other implementations can be within the scope of the following claims. 

What is claimed:
 1. A computer-implemented method, comprising: defining at least one file containing a plurality of artifacts for deploying during runtime of an application, each artifact in the plurality of artifacts including at least one object in the plurality of objects required to be deployed during runtime of the application; determining, based on the defining, at least one dependency for at least one artifact in the plurality of artifacts; generating, based on the determining, an execution order for deployment of the plurality of artifacts; and deploying the plurality of artifacts in accordance with the generated execution order, the deploying comprising deploying the plurality of artifacts using a database schema container having at least one synonym linking at least one external schema object to the at least one object in the plurality of objects using a container-local name; wherein at least one of the defining, the determining, the generating, and the deploying is performed by at least one processor of at least one computing system.
 2. The method according to claim 1, wherein the deploying includes at least one of the following: undeploying the at least one artifact, deploying a modified version of the at least one artifact, re-deploying the at least one artifact.
 3. The method according to claim 1, further comprising determining whether the at least one artifact is cyclically dependent on at least another artifact in the plurality of artifacts; prohibiting deployment of the at least one artifact and the at least another artifact based on a determination that the at least one artifact and the at least another artifact do not belong to the same build plugin, where the build plugin is used to deploy the at least one artifact at runtime of the application; and permitting deployment of the at least one artifact and the at least another artifact based on a determination that the at least one artifact and the at least another artifact belong to the same build plugin.
 4. The method according to claim 1, further comprising generating a dependency graph for the plurality of the artifacts based on the plurality of required objects; wherein the execution order is generated based on the generated dependency graph.
 5. The method according to claim 1, wherein the deploying further comprises initially deploying, based on the generated execution order, the plurality of artifacts; modifying the at least one artifact in the plurality of artifacts; generating a modified execution order, where the modified execution order specifies deployment of the at least one modified artifact; and deploying the plurality of artifacts including the at least one modified artifact based on the modified execution order.
 6. The method according to claim 5, further comprising determining at least another artifact in the plurality of artifacts being dependent on the at least one artifact; and redeploying the at least another artifact as a result of the modification of the at least one artifact.
 7. The method according to claim 5, further comprising determining at least another artifact in the plurality of artifacts being dependent on the at least one artifact; and undeploying the at least another artifact prior to deploying the at least one modified artifact; deploying the at least one modified artifact; and redeploying the at least another artifact after deploying the at least one modified artifact.
 8. The method according to claim 1, wherein the at least one dependency includes at least one of the following: the at least one artifact being dependent on at least another artifact in the plurality of artifacts and the at least one artifact being independent of any artifact in the plurality of artifacts.
 9. A system comprising: at least one programmable processor; and a machine-readable medium storing instructions that, when executed by the at least one programmable processor, cause the at least one programmable processor to perform operations comprising: defining at least one file containing a plurality of artifacts for deploying during runtime of an application, each artifact in the plurality of artifacts including at least one object in the plurality of objects required to be deployed during runtime of the application; determining, based on the defining, at least one dependency for at least one artifact in the plurality of artifacts; generating, based on the determining, an execution order for deployment of the plurality of artifacts; and deploying the plurality of artifacts in accordance with the generated execution order, the deploying comprising deploying the plurality of artifacts using a database schema container having at least one synonym linking at least one external schema object to the at least one object in the plurality of objects using a container-local name.
 10. The system according to claim 9, wherein the deploying includes at least one of the following: undeploying the at least one artifact, deploying a modified version of the at least one artifact, re-deploying the at least one artifact.
 11. The system according to claim 9, wherein the operations further comprise determining whether the at least one artifact is cyclically dependent on at least another artifact in the plurality of artifacts; prohibiting deployment of the at least one artifact and the at least another artifact based on a determination that the at least one artifact and the at least another artifact do not belong to the same build plugin, where the build plugin is used to deploy the at least one artifact at runtime of the application; and permitting deployment of the at least one artifact and the at least another artifact based on a determination that the at least one artifact and the at least another artifact belong to the same build plugin.
 12. The system according to claim 9, wherein the operations further comprise generating a dependency graph for the plurality of the artifacts based on the plurality of required objects; wherein the execution order is generated based on the generated dependency graph.
 13. The system according to claim 9, wherein the deploying further comprises initially deploying, based on the generated execution order, the plurality of artifacts; modifying the at least one artifact in the plurality of artifacts; generating a modified execution order, where the modified execution order specifies deployment of the at least one modified artifact; and deploying the plurality of artifacts including the at least one modified artifact based on the modified execution order.
 14. The system according to claim 13, wherein the operations further comprise determining at least another artifact in the plurality of artifacts being dependent on the at least one artifact; and redeploying the at least another artifact as a result of the modification of the at least one artifact.
 15. The system according to claim 13, wherein the operations further comprise determining at least another artifact in the plurality of artifacts being dependent on the at least one artifact; and undeploying the at least another artifact prior to deploying the at least one modified artifact; deploying the at least one modified artifact; and redeploying the at least another artifact after deploying the at least one modified artifact.
 16. The system according to claim 9, wherein the at least one dependency includes at least one of the following: the at least one artifact being dependent on at least another artifact in the plurality of artifacts and the at least one artifact being independent of any artifact in the plurality of artifacts.
 17. A computer program product comprising a machine-readable medium storing instructions that, when executed by at least one programmable processor, cause the at least one programmable processor to perform operations comprising: defining at least one file containing a plurality of artifacts for deploying during runtime of an application, each artifact in the plurality of artifacts including at least one object in the plurality of objects required to be deployed during runtime of the application; determining, based on the defining, at least one dependency for at least one artifact in the plurality of artifacts; generating, based on the determining, an execution order for deployment of the plurality of artifacts; and deploying the plurality of artifacts in accordance with the generated execution order, the deploying comprising deploying the plurality of artifacts using a database schema container having at least one synonym linking at least one external schema object to the at least one object in the plurality of objects using a container-local name.
 18. The computer program product according to claim 17, wherein the deploying includes at least one of the following: undeploying the at least one artifact, deploying a modified version of the at least one artifact, re-deploying the at least one artifact.
 19. The computer program product according to claim 17, wherein the operations further comprise determining whether the at least one artifact is cyclically dependent on at least another artifact in the plurality of artifacts; prohibiting deployment of the at least one artifact and the at least another artifact based on a determination that the at least one artifact and the at least another artifact do not belong to the same build plugin, where the build plugin is used to deploy the at least one artifact at runtime of the application; and permitting deployment of the at least one artifact and the at least another artifact based on a determination that the at least one artifact and the at least another artifact belong to the same build plugin.
 20. The computer program product according to claim 17, wherein the operations further comprise generating a dependency graph for the plurality of the artifacts based on the plurality of required objects; wherein the execution order is generated based on the generated dependency graph. 